# ===============================================================
# Librerías para Visualización y Procesamiento Numérico
# ===============================================================
import matplotlib.pyplot as plt  # Biblioteca para generar gráficos y visualizar resultados de procesamiento
import numpy as np               # Biblioteca para operaciones numéricas y manejo de arrays
import re                        # Biblioteca para manejo de expresiones regulares y procesamiento de texto


# ===============================================================
# Librerías para Procesamiento de Imágenes y Umbralización
# ===============================================================
!pip install pillow-heif                         # Instala soporte para imágenes HEIF/HEIC
!pip -q install opencv-python-headless           # Instala OpenCV sin componentes gráficos

from skimage import data                         # Carga imágenes de ejemplo
from skimage.filters import threshold_otsu       # Umbralización automática (Otsu)
from skimage.filters import threshold_multiotsu  # Umbralización multiclase (más de dos niveles)
from skimage.filters import try_all_threshold    # Prueba varios métodos de umbralización

import cv2                                       # Procesamiento de imágenes y visión por computadora
import imageio.v3 as iio                         # Lectura y escritura de imágenes en distintos formatos
from PIL import Image                            # Manipulación y visualización de imágenes
from pillow_heif import register_heif_opener     # Permite abrir imágenes HEIC/HEIF en PIL

register_heif_opener()                           # Activa el soporte HEIF/HEIC en PIL


# ===============================================================
# UTILIDADES Y MANEJO DEL SISTEMA
# ===============================================================
import gdown                                # Descarga de archivos desde Google Drive
import os                                   # Operaciones del sistema operativo
import sys                                  # Parámetros y funciones específicas del sistema
import socket                               # Interfaz de red de bajo nivel
import platform                             # Información sobre la plataforma
import pathlib                              # Manejo orientado a objetos de rutas
from datetime import datetime               # Manejo de fechas y horas
from zoneinfo import ZoneInfo               # Manejo de zonas horarias

# ===============================================================
# MENSAJE DE CONFIRMACIÓN
# ===============================================================
print("✅ Librerías cargadas")
print(f"📅 Timestamp de ejecución: {datetime.now(ZoneInfo('America/Mexico_City')).strftime('%Y-%m-%d %H:%M:%S')}")

try:
    with urlopen('https://ipapi.co/country_name/') as response:
        country = response.read().decode('utf-8').strip()
    print(f"🌍 País de ejecución: {country}")
    with urlopen('https://ipapi.co/region/') as response:
        region = response.read().decode('utf-8').strip()
    print(f"🗺️ Estado/Región de ejecución: {region}")
except Exception as e:
    print("No se pudo determinar el país o estado de ejecución (posiblemente sin conexión a internet).")

print("Python:", sys.version)
print("Ejecutable:", sys.executable)
print("Plataforma:", platform.platform())
print("Hostname:", socket.gethostname())
print("Carpeta trabajo:", os.getcwd())
print("Usuario:", pathlib.Path.home())

Collecting pillow-heif
  Downloading pillow_heif-1.1.1-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl.metadata (9.6 kB)
Requirement already satisfied: pillow>=11.1.0 in /usr/local/lib/python3.12/dist-packages (from pillow-heif) (11.3.0)
Downloading pillow_heif-1.1.1-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl (5.5 MB)
   ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 5.5/5.5 MB 32.3 MB/s eta 0:00:00
Installing collected packages: pillow-heif
Successfully installed pillow-heif-1.1.1
✅ Librerías cargadas
📅 Timestamp de ejecución: 2025-10-30 20:54:13
No se pudo determinar el país o estado de ejecución (posiblemente sin conexión a internet).
Python: 3.12.12 (main, Oct 10 2025, 08:52:57) [GCC 11.4.0]
Ejecutable: /usr/bin/python3
Plataforma: Linux-6.6.105+-x86_64-with-glibc2.35
Hostname: 13b6db1eb6b4
Carpeta trabajo: /content
Usuario: /root

# ===============================================================
# Limpiar todos los archivos en las carpetas especificadas
# ===============================================================
print("\n--- Limpiando archivos en las carpetas especificadas ---")
directorios_a_limpiar = ["imagenes_nuevas", "data", "p2_coins", "p2b_plates", "p2c_wheresimba", "bay"]

for directorio in directorios_a_limpiar:
    if os.path.exists(directorio):
        print(f"Eliminando contenido de la carpeta '{directorio}'...")
        for filename in os.listdir(directorio):
            file_path = os.path.join(directorio, filename)
            try:
                if os.path.isfile(file_path) or os.path.islink(file_path):
                    os.unlink(file_path)  # Eliminar archivo o enlace simbólico
                elif os.path.isdir(file_path):
                    shutil.rmtree(file_path)  # Eliminar subcarpetas
            except Exception as e:
                print(f"Error al eliminar {file_path}: {e}")
        print(f"Carpeta '{directorio}' limpiada.")
    else:
        print(f"La carpeta '{directorio}' no existe, no requiere limpieza.")


# ===============================================================
#  PARTE 1: DESCARGA LISTA DE IMÁGENES
# ===============================================================

# --- 1. Preparar el directorio de salida original ---
output_dir_original = "imagenes_nuevas"
if not os.path.exists(output_dir_original):
    os.makedirs(output_dir_original)
    print(f"Carpeta '{output_dir_original}' creada.")

# --- 2. Definir las imágenes a descargar ---
imagenes_a_descargar = {
    "01 - Cerro de a Silla Monterrey.HEIC": "1anUZCFwSnZII15MDqGb5sApYhmoXqx18",
    "02 - The Killers Las Vegas.HEIC": "1iizEGyZRAQJ-zcu4MOMdo_OATKvQ8HMr",
    "03 - Bellagio at Night.HEIC": "1u7N9au9fdDat9GYgK215SrSYfWVMLvSK",
    "04 - The Great Canyon.heic": "1zmudHsvMzDmITmQljkq7MOeAoaJj4gxo",
    "05 - The Cosmopolitan Las Vegas.HEIC": "1JymKRxsTuiIeuviO9RwotmQqRJ838V-m",
    "06 - Chinese Dragon.heic": "1rdBFw1yUmmXQqFca6iUppbYgSgzGorge",
    "07 - The Park Las Vegas.HEIC": "1BJD1hWP17PsF7pelR7zCW91sNb5cK31m",
    "08 - Simba Snow.HEIC": "1BOLxQGbKCZtRwA6wVyCBaKgowZfBrJGD"
}

print("\n--- Iniciando la descarga de la lista de imágenes ---")

# --- 3. Bucle para descargar cada imagen de la lista ---
for filename, file_id in imagenes_a_descargar.items():
    output_path = os.path.join(output_dir_original, filename)
    print(f"Descargando '{filename}'...")
    gdown.download(id=file_id, output=output_path, quiet=False)


# --- 4. Se repiten los pasos 1, 2 y 3 para otra carpeta de imagenes ---
output_dir_original = "bay"
if not os.path.exists(output_dir_original):
    os.makedirs(output_dir_original)
    print(f"Carpeta '{output_dir_original}' creada.")
imagenes_a_descargar = {
    "bay_coittower.heic": "1iFjGeiMmJukD8olvg9hLiGt6MHo7doGh",
    "bay_ferry.heic": "1gvdXLQwSGkQ8S2zb-NARRmX_in4fJwMy",
    "bay_goldengate.jpeg": "14mICfajLYyKzaVGH9zUZkuAmTo8QT-7j",
    "bay_lifebuoy.jpeg": "1rkrXljdLPA7NpuA-GtLbFcFrzX2ns1O4",
    "bay_sailboats.jpeg": "1Qq4cMtXN6dnUSMdBj2PMn_oc5vzcRvvM",
    "bay_sanfrancisco.heic": "1z-QuwqPhShxBBqwH7VG5i3dniEutLgdS",
    "bay_sausalito.jpeg": "19Rsp858V4zbi5nxqiOl6dKJ3kRdTr8vd",
    "bay_seagull.heic": "1acKuzQN9w6R5KmhoFEKINP5nCw507ZHw",
    "bay_skyline": "16w_Vj7byo5uiFJhIMO5dipvPXqKbqL-E",
    "bay_sunset": "1augsryFJdJYtByVxarHImjJByZAvUBL1",
    "bay_wheel": "1JJDEUG20SKoOTyeBRIViWgKunVnHlMW_"
}
for filename, file_id in imagenes_a_descargar.items():
    output_path = os.path.join(output_dir_original, filename)
    print(f"Descargando '{filename}'...")
    gdown.download(id=file_id, output=output_path, quiet=False)


print("\n✅ ¡Descarga de la lista completada!")

--- Limpiando archivos en las carpetas especificadas ---
La carpeta 'imagenes_nuevas' no existe, no requiere limpieza.
La carpeta 'data' no existe, no requiere limpieza.
La carpeta 'p2_coins' no existe, no requiere limpieza.
La carpeta 'p2b_plates' no existe, no requiere limpieza.
La carpeta 'p2c_wheresimba' no existe, no requiere limpieza.
La carpeta 'bay' no existe, no requiere limpieza.
Carpeta 'imagenes_nuevas' creada.

--- Iniciando la descarga de la lista de imágenes ---
Descargando '01 - Cerro de a Silla Monterrey.HEIC'...

Downloading...
From: https://drive.google.com/uc?id=1anUZCFwSnZII15MDqGb5sApYhmoXqx18
To: /content/imagenes_nuevas/01 - Cerro de a Silla Monterrey.HEIC
100%|██████████| 1.40M/1.40M [00:00<00:00, 99.1MB/s]

Descargando '02 - The Killers Las Vegas.HEIC'...

Downloading...
From: https://drive.google.com/uc?id=1iizEGyZRAQJ-zcu4MOMdo_OATKvQ8HMr
To: /content/imagenes_nuevas/02 - The Killers Las Vegas.HEIC
100%|██████████| 2.06M/2.06M [00:00<00:00, 49.0MB/s]

Descargando '03 - Bellagio at Night.HEIC'...

Downloading...
From: https://drive.google.com/uc?id=1u7N9au9fdDat9GYgK215SrSYfWVMLvSK
To: /content/imagenes_nuevas/03 - Bellagio at Night.HEIC
100%|██████████| 4.16M/4.16M [00:00<00:00, 53.0MB/s]

Descargando '04 - The Great Canyon.heic'...

Downloading...
From: https://drive.google.com/uc?id=1zmudHsvMzDmITmQljkq7MOeAoaJj4gxo
To: /content/imagenes_nuevas/04 - The Great Canyon.heic
100%|██████████| 1.37M/1.37M [00:00<00:00, 44.1MB/s]

Descargando '05 - The Cosmopolitan Las Vegas.HEIC'...

Downloading...
From: https://drive.google.com/uc?id=1JymKRxsTuiIeuviO9RwotmQqRJ838V-m
To: /content/imagenes_nuevas/05 - The Cosmopolitan Las Vegas.HEIC
100%|██████████| 4.16M/4.16M [00:00<00:00, 113MB/s]

# Cargar imagen de ejemplo
image = data.camera()

# Calcular umbral óptimo con Otsu
thresh = threshold_otsu(image)
binary = image > thresh

# Crear figura con 3 columnas
fig, axes = plt.subplots(ncols=3, figsize=(12, 4))
ax = axes.ravel()

# Imagen original
ax[0].imshow(image, cmap='gray')
ax[0].set_title('Imagen original')
ax[0].axis('off')

# Histograma con línea de umbral
ax[1].hist(image.ravel(), bins=256, color='blue', alpha=0.7)
ax[1].axvline(thresh, color='red', linestyle='--', linewidth=2, label=f'Umbral = {thresh:.0f}')
ax[1].set_title('Histograma de intensidades')
ax[1].set_xlabel('Intensidad')
ax[1].set_ylabel('Frecuencia')
ax[1].legend()

# Imagen umbralizada
ax[2].imshow(binary, cmap='gray')
ax[2].set_title('Imagen binarizada (Otsu)')
ax[2].axis('off')

# Ajustar espaciado
plt.tight_layout()
plt.show()

# Cargar imagen
img = data.page()

# Aplicar todos los métodos de umbralización disponibles
fig, ax = try_all_threshold(img, figsize=(14, 10), verbose=False)

for a in ax:
    a.set_title(a.get_title(), fontsize=10)
    a.axis('off')
    a.images[0].set_cmap('gray')

plt.tight_layout()
plt.show()

# Cargar imagen
image = data.camera()

# Aplicar Multi-Otsu para generar tres clases
thresholds = threshold_multiotsu(image)

# Clasificar píxeles según los umbrales obtenidos
regions = np.digitize(image, bins=thresholds)

# Crear figura con tres subgráficos
fig, ax = plt.subplots(nrows=1, ncols=3, figsize=(14, 4))
titles = ['Imagen original', 'Histograma con umbrales', 'Segmentación Multi-Otsu']

# Imagen original
ax[0].imshow(image, cmap='gray')
ax[0].set_title(titles[0], fontsize=12)
ax[0].axis('off')

# Histograma con líneas de umbral
ax[1].hist(image.ravel(), bins=256, color='steelblue', alpha=0.7)
for thresh in thresholds:
    ax[1].axvline(thresh, color='darkred', linestyle='--', linewidth=2, label=f'Umbral = {thresh}')
ax[1].set_title(titles[1], fontsize=12)
ax[1].set_xlabel('Intensidad')
ax[1].set_ylabel('Frecuencia')
ax[1].legend()

# Imagen segmentada con mapa de color perceptual
ax[2].imshow(regions, cmap='jet')
ax[2].set_title(titles[2], fontsize=12)
ax[2].axis('off')

plt.tight_layout()
plt.show()

def visualizar_resultados(imagen_array, umbral, imagen_binaria, thresholds, regions):
    fig, ax = plt.subplots(nrows=1, ncols=5, figsize=(18, 4))

    # 1) Imagen original en escala de grises
    ax[0].imshow(imagen_array, cmap='gray')
    ax[0].set_title("Imagen original", fontsize=11)
    ax[0].axis('off')

    # 2) Histograma con umbral simple
    ax[1].hist(imagen_array.ravel(), bins=256, color='steelblue', alpha=0.7)
    ax[1].axvline(umbral, color='darkred', linestyle='--', linewidth=2, label=f'Umbral = {umbral:.2f}')
    ax[1].set_title("Histograma (Otsu)", fontsize=11)
    ax[1].set_xlabel("Intensidad")
    ax[1].set_ylabel("Frecuencia")
    ax[1].legend()

    # 3) Imagen binaria (usar cmap='gray')
    ax[2].imshow(imagen_binaria, cmap='gray')
    ax[2].set_title("Imagen binaria", fontsize=11)
    ax[2].axis('off')

    # 4) Histograma con multi-umbrales
    ax[3].hist(imagen_array.ravel(), bins=256, color='steelblue', alpha=0.7)
    for t in thresholds:
        ax[3].axvline(t, color='darkred', linestyle='--', linewidth=2)
    ax[3].set_title("Histograma (Multi-Otsu)", fontsize=11)
    ax[3].set_xlabel("Intensidad")

    # 5) Imagen segmentada por múltiples regiones usando 'jet'
    ax[4].imshow(regions, cmap='jet')
    ax[4].set_title("Regiones (Multi-Otsu)", fontsize=11)
    ax[4].axis('off')

    plt.tight_layout()
    plt.show()

rutas_imagenes = [
    os.path.join("imagenes_nuevas", "05 - The Cosmopolitan Las Vegas.HEIC"),
    os.path.join("imagenes_nuevas", "06 - Chinese Dragon.heic"),
    os.path.join("imagenes_nuevas", "07 - The Park Las Vegas.HEIC"),
    os.path.join("bay", "bay_coittower.heic"),
    os.path.join("bay", "bay_ferry.heic"),
    os.path.join("bay", "bay_goldengate.jpeg"),
    os.path.join("bay", "bay_lifebuoy.jpeg"),
    os.path.join("bay", "bay_sailboats.jpeg"),
    os.path.join("bay", "bay_sanfrancisco.heic"),
    os.path.join("bay", "bay_sausalito.jpeg"),
    os.path.join("bay", "bay_seagull.heic"),
    os.path.join("bay", "bay_skyline"),
    os.path.join("bay", "bay_sunset"),
    os.path.join("bay", "bay_wheel")
]

for ruta in rutas_imagenes:
    imagen_rgb = iio.imread(ruta)
    imagen_pil = Image.fromarray(imagen_rgb)
    imagen_gris = imagen_pil.convert("L")
    imagen_array = np.array(imagen_gris)
    umbral = threshold_otsu(imagen_array)
    imagen_binaria = imagen_array > umbral
    thresholds = threshold_multiotsu(imagen_array)
    regions = np.digitize(imagen_array, bins=thresholds)
    visualizar_resultados(imagen_array, umbral, imagen_binaria, thresholds, regions)

for ruta in rutas_imagenes:
    print(f"\nProcesando: {ruta}")

    # --- Cargar y a gris ---
    imagen_rgb = iio.imread(ruta)
    imagen_pil = Image.fromarray(imagen_rgb)
    imagen_gris = imagen_pil.convert("L")
    imagen_array = np.array(imagen_gris)

    # --- 1) Ejecutar try_all_threshold SIN mostrar nada ---
    with plt.ioff():
        fig_tmp, ax_tmp = try_all_threshold(imagen_array, figsize=(12, 8), verbose=False)

    # Aplanar ejes y extraer (título, imagen)
    axes_list = np.array(ax_tmp).ravel().tolist()
    results = [(a.get_title(), a.images[0].get_array()) for a in axes_list]
    results = results[:8]  # fuerza 8 métodos
    n_methods = len(results)

    # --- 2) Cerrar cualquier figura pendiente para que Colab no la muestre ---
    plt.close('all')

    # --- 3) Crear la figura final: 1 fila x 8 columnas ---
    fig, axes = plt.subplots(nrows=1, ncols=n_methods, figsize=(3*n_methods, 3))
    if n_methods == 1:
        axes = [axes]

    for ax, (title, img_bin) in zip(axes, results):
        ax.imshow(img_bin, cmap='gray', interpolation='nearest')
        ax.set_title(title, fontsize=9)
        ax.axis('off')

    fig.suptitle(f"Comparación de Umbralización (1x{n_methods}) - {os.path.basename(ruta)}", fontsize=12)

    # --- 4) Mostrar figura ---
    plt.tight_layout()
    plt.show()

Procesando: imagenes_nuevas/05 - The Cosmopolitan Las Vegas.HEIC

Procesando: imagenes_nuevas/06 - Chinese Dragon.heic

Procesando: imagenes_nuevas/07 - The Park Las Vegas.HEIC

Procesando: bay/bay_coittower.heic

Procesando: bay/bay_ferry.heic

Procesando: bay/bay_goldengate.jpeg

Procesando: bay/bay_lifebuoy.jpeg

Procesando: bay/bay_sailboats.jpeg

Procesando: bay/bay_sanfrancisco.heic

Procesando: bay/bay_sausalito.jpeg

def download_drive_folder_public(folder_url_or_id: str, dest_dir: str):
    import gdown
    os.makedirs(dest_dir, exist_ok=True)

    # Accept URL or raw ID
    if re.search(r'/folders/([a-zA-Z0-9_-]{10,})', folder_url_or_id):
        url = folder_url_or_id
    else:
        url = f"https://drive.google.com/drive/folders/{folder_url_or_id}"

    # remaining_ok allows partial downloads to resume
    gdown.download_folder(url=url, output=dest_dir, quiet=False, use_cookies=False, remaining_ok=True)
    print(f"Done. Files saved under: {os.path.abspath(dest_dir)}")

def list_folder_contents(base_folder: str) -> list:
    file_list = []
    for root, _, files in os.walk(base_folder):
        for f in files:
            relative_path = os.path.join(root, f)
            file_list.append(relative_path)
    return sorted(file_list)


def decode_qr_all(img_uint8):
    det = cv2.QRCodeDetector()
    results = []
    try:
        retval, decoded_info, points, _ = det.detectAndDecodeMulti(img_uint8)
        if retval and points is not None:
            for txt, pts in zip(decoded_info, points):
                if txt:
                    results.append((txt, pts))
    except Exception:
        pass
    if not results:
        txt, pts, _ = det.detectAndDecode(img_uint8)
        if txt:
            results.append((txt, pts))
    return results

def draw_qr_boxes(ax, base_img_rgb, results):
    ax.imshow(base_img_rgb)
    ax.axis('off')
    for txt, pts in results:
        if pts is None:
            continue
        pts = pts.reshape(-1, 2).astype(int)
        poly = np.vstack([pts, pts[0]])
        ax.plot(poly[:,0], poly[:,1], linewidth=2)
        ax.text(pts[0,0], pts[0,1]-5, txt[:40], fontsize=9, bbox=dict(facecolor='white', alpha=0.6))

# Descargando las imagenes de la carpeta
download_drive_folder_public(
    "https://drive.google.com/drive/folders/1CbcVoFIuJg0VZiR26RXPDyObQK14Djci?usp=drive_link",
    "/content/qr"
)

# Enlistando las imagenes descargadas
rutas_imagenes = list_folder_contents("qr")

Retrieving folder contents

Processing file 1I4cOoT-1iQbc1tg8hesw5ARFy-9CeXu4 qrcode1.png
Processing file 1QpxBMNUCGM_6182tWV8YSMFBriOHgT7_ qrcode3.HEIC
Processing file 1pzq1psm095LtAmTbDLX_g8B60PB1Nqkp qrcode4.HEIC

Retrieving folder contents completed
Building directory structure
Building directory structure completed
Downloading...
From: https://drive.google.com/uc?id=1I4cOoT-1iQbc1tg8hesw5ARFy-9CeXu4
To: /content/qr/qrcode1.png
100%|██████████| 27.7k/27.7k [00:00<00:00, 22.2MB/s]
Downloading...
From: https://drive.google.com/uc?id=1QpxBMNUCGM_6182tWV8YSMFBriOHgT7_
To: /content/qr/qrcode3.HEIC
100%|██████████| 2.48M/2.48M [00:00<00:00, 104MB/s]
Downloading...
From: https://drive.google.com/uc?id=1pzq1psm095LtAmTbDLX_g8B60PB1Nqkp
To: /content/qr/qrcode4.HEIC
100%|██████████| 2.18M/2.18M [00:00<00:00, 172MB/s]

Done. Files saved under: /content/qr

Download completed

# Se aplica el flujo de trabajo
for ruta in rutas_imagenes:
    # Aplicar OTSU
    imagen_rgb = iio.imread(ruta)
    imagen_pil = Image.fromarray(imagen_rgb)
    imagen_gris = imagen_pil.convert("L")
    imagen_array = np.array(imagen_gris)
    umbral = threshold_otsu(imagen_array)
    imagen_binaria = (imagen_array > umbral).astype(np.uint8) * 255

    #Extraer QRs sobre imagen binaria (OTSU)
    results = decode_qr_all(imagen_binaria)

    # Desplegar imagenes
    print(f"*"*100)
    print(f"Analizando archivo {ruta}")
    print(f"*"*100)
    plt.figure(figsize=(12,5))
    plt.subplot(1,2,1)
    plt.imshow(imagen_binaria, cmap='gray')
    plt.title('Imagen Binaria (OTSU)')
    plt.axis('off')
    plt.subplot(1,2,2)
    draw_qr_boxes(plt.gca(), imagen_rgb, results)
    plt.title('Detección QR (sobre original)')
    plt.show()

    # Imprimir resultados
    if results:
      print(f"*"*100)
      print(f"CÓDIGOS QR ENCONTRADOS!")
      print(f"*"*100)
      for i, (txt, _) in enumerate(results, 1):
            print(f"  >>>[{i}] {txt}")
    else:
        print(f"{ruta}: No se encontraron códigos QR")

    print("\n" * 3)

****************************************************************************************************
Analizando archivo qr/qrcode1.png
****************************************************************************************************

****************************************************************************************************
CÓDIGOS QR ENCONTRADOS!
****************************************************************************************************
  >>>[1] https://myqrcode.mobi/fc69d759


****************************************************************************************************
Analizando archivo qr/qrcode3.HEIC
****************************************************************************************************

****************************************************************************************************
CÓDIGOS QR ENCONTRADOS!
****************************************************************************************************
  >>>[1] OSCAR GARCIA
  >>>[2] LUIS SANCHEZ
  >>>[3] JUAN CARLOS PEREZ
  >>>[4] JAVIER REBULL


****************************************************************************************************
Analizando archivo qr/qrcode4.HEIC
****************************************************************************************************

****************************************************************************************************
CÓDIGOS QR ENCONTRADOS!
****************************************************************************************************
  >>>[1] PART_ID:178431/DESCRIPTION:FANUC_ROBOT_MOTOR_AXIS2

Carpeta	Contenido
`imagenes_nuevas/`	Primer grupo de imágenes descargadas
`bay/`	Segundo grupo de imágenes descargadas
Resto de carpetas (`data/`, `p2_*`)	Limpias y listas para procesamiento

Algoritmo	Tipo	Principio	Ideal para…
Otsu	Automático, único	Maximiza la varianza entre clases	Imágenes con histograma bimodal
Li	Automático, único	Minimiza la entropía cruzada	Imágenes con ruido o gradientes suaves
Yen	Automático, único	Maximiza la entropía de la imagen	Segmentación con contraste alto
Triangle	Automático, único	Geometría del histograma	Distribuciones asimétricas
Mean	Manual, único	Promedio de intensidades	Casos simples o controlados
Minimum	Automático, único	Busca mínimos locales en el histograma	Imágenes con múltiples modos
Isodata	Iterativo, único	Promedia clases hasta converger	Distribuciones complejas
Multi-Otsu	Automático, múltiple	Extiende Otsu a múltiples clases	Segmentación en más de dos regiones

Método	Supuesto / Característica	Comentario
Otsu	Histograma bimodal	Funciona bien cuando fondo y objeto son claramente distintos.
Li / Yen	Optimización basada en entropía o energía	Útiles cuando el contraste no es evidente.
Triangle	Basado en la geometría del histograma	Puede ser más robusto ante ruido o asimetrías.
Mean	Simple promedio global	Rápido pero menos preciso si la iluminación no es uniforme.

Símbolo	Significado
$\omega_k$	probabilidad (frecuencia relativa) de la clase k
$\mu_k$	media de intensidades de la clase k
$\mu_T$	media global de toda la imagen

Situación	Adecuado
La imagen contiene 3 o más regiones claramente diferenciables	✔️ Sí
La iluminación es relativamente uniforme	✔️ Sí
La imagen es ruidosa o poco contrastada	⚠️ Puede degradarse el desempeño

Panel	Contenido	Descripción
1. Imagen original	`cmap='gray'`	Muestra la imagen en escala de grises tal como fue cargada. Sirve como referencia inicial.
2. Histograma + Umbral (Otsu)	`axvline(umbral)`	Se grafica el histograma de intensidades y se marca el umbral óptimo calculado con Otsu. Permite observar si la distribución es bimodal.
3. Imagen binaria	`cmap='gray'`	Después de aplicar el umbral, se genera una imagen blanco/negro que separa objeto y fondo. Resultado directo de Otsu.
4. Histograma Multiclase (Multi-Otsu)	Líneas verticales múltiples	Se vuelven a graficar las intensidades, pero ahora se marcan múltiples umbrales (K−1) obtenidos con Multi-Otsu.
5. Imagen segmentada multiclase	`cmap='jet'`	La imagen se divide en regiones diferenciadas por color, asignando una etiqueta (clase) a cada pixel. Esto permite distinguir más de dos grupos visualmente.

Beneficio	Descripción
Comparación directa	Una fila horizontal 1×8 facilita ver diferencias entre métodos en la misma escala visual.
Selección informada	Permite elegir el algoritmo más estable ante reflejos, sombras y texturas reales.
Control en Colab	Evita figuras duplicadas y asegura una única salida limpia por imagen.

Habilidad	Resultado
🧠 Comprender Otsu	Saber cuándo y por qué usarlo en imágenes para QR
🖼️ Preprocesar imágenes	Convertir imágenes reales a binario de alta calidad
🔍 Decodificar QR	Extraer correctamente la información contenida
🏭 Aplicar a contexto real	Identificar casos donde esto mejora procesos logísticos e industriales

Condición de la Imagen	Efecto Observado
Alto contraste definido	Otsu genera segmentaciones estables y limpias
Gradientes suaves o neblina	Multi-Otsu identifica rangos intermedios más útiles
Superficies con reflejos	Algunos métodos basados en entropía (Li, Yen) producen segmentaciones más equilibradas
Texturas irregulares (agua)	Métodos simples como Mean o Triangle tienden a fragmentar resultados

🎓 Maestría en Inteligencia Artificial Aplicada¶

🖼️ Visión Computacional para Imágenes y Video¶

👨‍🏫 Profesores¶

Actividad 9.4: Google Colab con algoritmo Otsu¶

📌 Detalles de la Actividad¶

👥 Team 13¶

🚀 Nuestro Equipo¶

Javier Augusto Rebull Saucedo¶

Juan Carlos Pérez Nava¶

Luis Gerardo Sánchez Salazar¶

Oscar Enrique García García¶

Objetivo del Proyecto¶

📚 Tabla de Contenidos¶

💻 Tecnologías Utilizadas¶

Importación de Librerías ¶

📦 Carga de Librerías y Configuración del Entorno¶

🔍 Librerías Principales¶

🖼️ Procesamiento de Imágenes y Umbralización¶

🖼️ Soporte para Formato HEIC/HEIF¶

🛠️ Utilidades del Sistema¶

✅ Mensaje Final¶

📂 Gestión de Carpetas y Descarga de Imágenes¶

🧹 1. Limpieza de Directorios Existentes¶

🗂️ 2. Preparación del Directorio de Descarga¶

⬇️ 3. Descarga de Imágenes desde Google Drive¶

🌁 4. Descarga Adicional en la Carpeta bay¶

✅ Resultado¶

Umbralización única ¶

🎯 Umbralización con el Método de Otsu¶

📊 Principio Estadístico¶

🧮 Fórmulas Clave¶

✅ Condiciones de Aplicabilidad¶

🔍 Comparación Visual de Métodos de Umbralización¶

🎛️ Diferencias Entre Métodos de Umbralización¶

🎯 ¿Por qué usar try_all_threshold?¶

Umbralización múltiple ¶

🎨 Segmentación Multiclase con Multi-Otsu¶

🧠 Idea Principal¶

🧮 Formulación¶

✅ ¿Cuándo usar Multi-Otsu?¶

🌉 Aplicación de Umbralización en Imágenes Reales y Personalizadas¶

🔍 Desglose de la Visualización¶

🎯 Propósito del Ejemplo¶

✨ Resultado Esperado¶

🔄 Flujo de Procesamiento en Cada Imagen¶

🎯 Resultado y Observación¶

🧭 Comparación Global de Métodos de Umbralización¶

🔍 Qué hace ahora el flujo¶

🎯 Valor del análisis¶

🎯 Mini-Proyecto: Detección y Segmentación de Códigos QR utilizando Umbralización de Otsu¶

📌 Introducción¶

⚙️ ¿Por qué Otsu para Códigos QR?¶

✅ Ventajas clave:¶

🧪 Casos de Uso incluidos en este mini-proyecto¶

1) 🟩 QR Limpio Generado en Página Web¶

2) 🏷️ Varios Códigos QR con Nombres del Equipo¶

3) 🤖 Código QR en Entorno Industrial¶

🎯 Objetivo del Mini-Proyecto¶

🏁 Resultado Esperado¶

🔧 Implementación¶

download_drive_folder_public(folder_url_or_id, dest_dir) 📁⬇️¶

list_folder_contents(base_folder) 🗂️¶

decode_qr_all(img_uint8) 🔍📦¶

draw_qr_boxes(ax, base_img_rgb, results) 🎨🧩¶

✅ Reflexión del Mini-Proyecto¶

🎯 Conclusiones¶

🔬 Comprensión de Umbralización Binaria y Multiclase¶

🌁 Aplicación en Imágenes Reales con Variabilidad Lumínica¶

🧭 Comparación Sistemática con try_all_threshold¶

🧩 Integración con el Mini-Proyecto de QR¶

Conclusiones Personales¶

✅ Conclusión General¶

📚 Referencias¶

🌁 4. Descarga Adicional en la Carpeta `bay`¶

🎯 ¿Por qué usar `try_all_threshold`?¶

`download_drive_folder_public(folder_url_or_id, dest_dir)` 📁⬇️¶

`list_folder_contents(base_folder)` 🗂️¶

`decode_qr_all(img_uint8)` 🔍📦¶

`draw_qr_boxes(ax, base_img_rgb, results)` 🎨🧩¶

🧭 Comparación Sistemática con `try_all_threshold`¶